mmt - ASP.NET Core api

Dit is een synthese van heel wat zaken die in Programmeren 3 en 5 hebben geleerd. Ik had gedacht dat de studenten dit alleen gingen kunnen maken. Maar het blijkt dat het nuttig is om te tonen hoe je kennis, die vroeger hebt geleerd, gebruikt om een nieuw project te realiseren. In deze tutorial verwijs ik dan ook naar elementen uit vorige vakken.

Stappenplan

Maak een nieuw ASP.NET Core API project in Visual Studio (of Visual Studio Code):
1. Selecteer New > Project in het menu File.
2. Selecteer de ASP.NET Core-webtoepassingssjabloon en klik op Next:
  
  Create a new ASP.NET Core project
3. Geef het project de naam mmt-api en klik op Create:
  
  Configure your new ASP.NET Core project
4. Controleer in het dialoogvenster Een nieuwe ASP.NET Core-webtoepassing maken of .NET Core en ASP.NET Core 3.1 is geselecteerd. Selecteer de API-sjabloon en klik op Create. Vink de opties Docker-ondersteuning en HTTPS niet aan:
  
  Create a new ASP.NET Core web application - no https
5. Vink je HTTPS wel aan moet je nog de volgende veiligheidsinstellingen doorlopen:
  
  Dialogbox IIS Express SSL certificate
  
  Dialogbox IIS Express SSL certificate Beveiligingswaarschuwing
MySQLConnctor installeren
1. Alle uitleg vind je op MySQL Data Providers voor .NET.
2. Open de NuGet package manager:
  
  Open NuGet Package Manager Console
Installeer de Install-Package MySqlConnector -Version 0.66.0 package:

NuGet Package Manager Console-Install-Package MySqlConnector

Visual Studio MySqlConnector package toegevoegd
Een Model klasse toevoegen
1. Hoe je dat doet hebben we in Programmeren 3 geleerd (EF Core - entiteit en model):
2. maak een submap met de naam Models;
3. klik op met de rechtermuisknop op de naam van de map en kies Add > Class;
4. geef aan het bestand de naam MmtLike.cs aan;
5. geef er de namespace MmtApi.Models aan;
6. de klassennaam is MmtLike;
7. plaats er de volgende code in:
```
namespace MmtApi.Models
{
    public class MmtLike
    {
        public int Id { get; set; }
        public string Key { get; set; }
        public string Name { get; set; }
        public long Likes { get; set; }
    }
}
```
8. De eigenschap Id doet dienst al de unieke sleutel in een relationele database.
  Modelklassen kunnen overal in het project terechtkomen, maar de map Models wordt volgens afspraak gebruikt.
Tabellen maken
Ik kies ervoor om geen migration te gebruiken en maak zelf de tabellen:

De MmtLikes tabel:

use Docent1;
CREATE TABLE `MmtLikes` (
    `Name` NVARCHAR (50) NOT NULL,
    `Key` NVARCHAR (5) NULL,
    `Likes` int,
    `Id` INT NOT NULL AUTO_INCREMENT,
    CONSTRAINT PRIMARY KEY(Id));

De MmtComments tabel:

use Docent1;
CREATE TABLE `MmtComments` (
    `Name` NVARCHAR (50) NOT NULL,
    `Key` NVARCHAR (5) NULL,
    `Comment` NVARCHAR(512),
    `Id` INT NOT NULL AUTO_INCREMENT,
    CONSTRAINT PRIMARY KEY(Id));

Installeer EntityFramework voor MySql
Tools > NuGet Package Manager > Manage NuGet Packages for Solution:

Install Pomelo EntityFramework package
Voeg een databasecontext toe
1. De DBContext is de hoofdklasse waarmee Entity Framework de functionaliteit voor een gegevensmodel coördineert. We hebben dat uitgebreid in Programmeren 3 gezien: EF Core - DbContext. Deze klasse is gemaakt op basis van de klasse Microsoft.EntityFrameworkCore.DbContext.
2. Klik met de rechtermuisknop op de map Modellen en selecteer Add > Class. Noem de klasse MmtContext en klik op Add.
3. Vergeet niet de EF library te gebruiken:
```
using Microsoft.EntityFrameworkCore;
```
4. Vervang de sjablooncode door de volgende code:
```
using Microsoft.EntityFrameworkCore;

namespace MmtApi.Models
{
    public class MmtContext : DbContext
    {
        public MmtContext(DbContextOptions<MmtContext> options)
                : base(options)
        {
        }

        public DbSet<MmtLike> MmtLikes { get; set; }
        public DbSet<MmtComment> MmtComments { get; set; }
    }
}
```

Registreer de databasecontext

In ASP.NET Core moeten services zoals de DB-context worden geregistreerd met de container voor dependency injection (DI). De container levert de service aan controllers. Dat hebben we ook uitgebreid gezien in Programmeren 3:
1. De .NET Core configuratie API
2. Inversion of Control en Dependency Injection in .NET Core
3. Marinko Spasojevic, Getting Started with Entity Framework Core in ASP.NET Core – Models, DbContext, Configuration, Jul 29, 2019

appsettings.json configuratiebestand (data hieronder is fake, pas die aan!):

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=mmt;Trusted_Connection=True;
                 MultipleActiveResultSets=true",
    "MmtLocal": "Server=92.222.220.213,1500;Database=_13875_JefInghelbrecht;User Id=sa;
                 Password=xxxxxxxx;MultipleActiveResultSets=true",
    "Mmt": "Server=510.380.370.150;user id=Docent1;password=Docent_XXXXXXXX;
                 port=3306;database=Docent1;SslMode=none"
  }
}

Het configuratie bestand lees je in tijdens de startup. In de Startup klasse. Je hoeft dat maar 1 keer te doen en dus doen we dat in de constructor van de Startup klasse in Startup.cs:

public Startup()
{
    var builder = new ConfigurationBuilder()
       .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
    Configuration = builder.Build();
}

de service registreren en met behulp van Dependency Injection doorgeven aan DBContext. Dat doen we in de ConfigureServices methode van de Startup klasse:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddDbContext<MmtContext>(options =>
            options.UseMySql(Configuration.GetConnectionString("Mmt")));
}

MmtLike Controller toevoegen
1. In Programmeren 3:
  1. ASP.NET MVC Controllers
  2. ASP.NET MVC Form Posts afhandelen
2. In de Startup geven we op dat we MVC patroon gaan gebruiken. We gebruiken daarvoor de volgende service:
```
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddDbContext<MmtContext>(options =>
            options.UseMySql(Configuration.GetConnectionString("Mmt")));
}
```
  Meer info hierover: Andrew Lock, Comparing Startup.cs between the ASP.NET Core 3.0 templates, September 03, 2019
3. Rechtermuis-klik op de Controllers folder
  1. Kies Add > New Item
  2. In de Add New Item dialog, selecteer de API Controller Class sjabloon
  3. Geef aan de klasse de naam MmtLikeController, en selecteer Add
4. Haal de connectie met de database op:
```
namespace MmtApi.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class MmtLikeController : ControllerBase
    {

        private readonly MmtContext mmtContext;
        public MmtLikeController(MmtContext context)
        {
            mmtContext = context;
        }
```
  1. declareer een DBcontext in de MmtLikeController
  2. initialiseer die in de constructor:
5. Voeg de PostLike methode toe:
  1. Als parameter neem deze methode een instantie van de MmtLike klasse aan.
  2. We kijken eerst als er een rij in de Like tabel zit met de waarde van Key. Als dat zo is wordt Likes met 1 vermeerderd. In het andere geval wordt er een nieuwe rij toevoegd en Likes krijgt de waarde 1.
  3. We gebruiken hier geen async responses. Het is al ingewikkeld genoeg. Meer info over async: Stephen Cleary, Async Programming: Introduction to Async/Await on ASP.NET, October 2014.
  4. De code:
```
[HttpPost]
public MmtLike PostLike(MmtLike item)
{
    var mmtLike = mmtContext.MmtLikes.Where(a => a.Key == item.Key).FirstOrDefault();

    if (mmtLike == null)
    {
        mmtContext.MmtLikes.Add(item);
        mmtContext.SaveChanges();
    }
    else
    {
        mmtLike.Likes = mmtLike.Likes + 1;
        mmtContext.MmtLikes.Update(mmtLike);
        mmtContext.SaveChanges();
    }
    return mmtLike;
}
```
  5. Test de PostLike methode
    1. We gebruiken Postman om de web API te testen.
    2. Installeer Postman.
    3. Start de web app (F5)
    4. Start Postman
    5. Maak een post request en geef de volgende json mee:
```
{
 "Key":"120",
"Name":"Een",
"Likes":1
}
```
    6. Overzicht van de uit te voeren stappen:
      
      mmt - postman - like post
    7. In de Workbench kan je verifiëren als de tabel is bijgewerkt:
      
      mmt - row in MmtLikes table created
  6. Voeg de GetLikes methode toe
    1. Als parameter geven we Key waarde mee van het artikel waarvan de Likes moeten worden opgehaald.
    2. We retourneren een MmtLike instantie die als JSON naar de client gestuurd zal worden.
    3. Code:
```
[HttpGet("{key}")]
public MmtLike GetLikes(string key)
{
    var mmtArticle = mmtContext.MmtLikes.Where(a => a.Key == key).FirstOrDefault();

    return mmtArticle;

}
```
    4. Test de PostLike methode
      1. We gebruiken Postman om de web API te testen.
      2. Start de web app (F5)
      3. Start Postman
      4. Maak een getrequest en geef de volgende url op:
        localhost:58013/MmtLike/120
      5. Overzicht van de uit te voeren stappen voor de request in het rood, om de response te zien, in het groen:
        
        mmt - postman - likes get
      6. Voer nog een PostLike request uit:
        
        mmt - postman - like post 2
      7. En tenslotte nog een get request om het resultaat te bekijken:
        
        mmt - postman - likes get 2

Opdracht

Maak een controllerklasse voor MmtComments met daarin twee methoden:
1. een post methode om een nieuwe comment aan een artikel toe te voegen
2. een get methode om alle comments van 1 artikel op te halen

2020-05-15 13:16:18